import * as amapFile from './amap.js';
import Cache from "./cache";
import config from '../common/config.js'
 const utils = {
	isAllChinese(str) {
		const regex = /^(?=.*[\u4E00-\u9FA5])[\s\S]{1,50}$/
		return regex.test(str);
	  },
	 //获取名称
	 getAddress(latitude, longitude,key,callBack){
			  let myAmapFun = new amapFile.AMapWX({key});
			  myAmapFun.getRegeo({
				location: '' + longitude + ',' + latitude + '',//location的格式为'经度,纬度'
				success: function (data) {
				  let {province,city,district,businessAreas} = data[0].regeocodeData.addressComponent;
				  let { name }=data[0].regeocodeData.pois[0]
				  city = (city || city?.length>0) ? city:"";
				  Cache.set('longitude',longitude)
				  Cache.set('latitude',latitude)
				  let obj={
					  province,
					  city,
					  district,
					  name:data[0].name,
					  businessAreaName:name
				  }
			      callBack&&callBack(obj)
				},
				fail: function (info) { }
		  })
	},
   addOneHour(timeStr,hour) {
	   let time = hour ? hour : 1
	  // 将时间字符串转换为 Date 对象
	  const date =timeStr ? new Date(timeStr.replace(' ', 'T')) : new Date()  // 处理日期时间格式

	  // 加一个小时
	  date.setHours(date.getHours() + time);

	  // 格式化回 'yyyy-mm-dd hh:mm:ss' 格式
	  const year = date.getFullYear();
	  const month = String(date.getMonth() + 1).padStart(2, '0');
	  const day = String(date.getDate()).padStart(2, '0');
	  const hours = String(date.getHours()).padStart(2, '0');
	  const minutes = String(date.getMinutes()).padStart(2, '0');
	  const seconds = String(date.getSeconds()).padStart(2, '0');

	  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
	},
	 calculateDuration(startTime, endTime) {
	    // 将时间字符串解析为小时和分钟
	    const [startHour, startMinute] = startTime.split(':').map(Number);
	    const [endHour, endMinute] = endTime.split(':').map(Number);

	    // 转换为总分钟数
	    const startTotalMinutes = startHour * 60 + startMinute;
	    const endTotalMinutes = endHour * 60 + endMinute;

	    // 计算时间差
	    let durationMinutes = endTotalMinutes - startTotalMinutes;

	    // 如果结束时间小于开始时间（跨天情况）
	    if (durationMinutes < 0) {
	        durationMinutes += 24 * 60; // 加一天的分钟数
	    }

	    // 转换为小时和分钟
	    const hours = Math.floor(durationMinutes / 60);
	    const minutes = durationMinutes % 60;

	    return { hours, minutes };
	},
	toast(title, icon = 'none', timeout = 1500) {
		return new Promise((success, fail) => {
			uni.showToast({
				title,
				icon,
				mask: true,
				duration: timeout,
				fail(res) {
					fail(res)
				}
			})
			setTimeout(() => {
				success();
			}, timeout);
		})
	},
    calculateDuration(startTime, endTime) {
	    // 为了确保两个时间在同一天，我们可以使用同一个日期部分
	    const datePart = '2025-01-09 '; // 使用今天的日期，但你可以根据需要更改

	    // 创建两个Date对象
	    const start = new Date(datePart + startTime);
	    const end = new Date(datePart + endTime);

	    // 计算时间差（以毫秒为单位）
	    const diffInMilliseconds = end - start;

	    // 将时间差转换为分钟
	    const diffInMinutes = diffInMilliseconds / (1000 * 60);

	    // 将分钟转换为小时和分钟
	    const hours = Math.floor(diffInMinutes / 60);
	    const minutes = Math.floor(diffInMinutes % 60);

	    // 返回结果
	    return minutes;
	},
	getCurrentDate(){
		const now = new Date();

		const year = now.getFullYear();
		const month = (now.getMonth() + 1).toString().padStart(2, '0'); // 月份补零
		const day = now.getDate().toString().padStart(2, '0'); // 日期补零

		// 返回格式化后的时间字符串，分钟和秒数固定为 00:00
		return `${year}-${month}-${day} 00:00:00`;
	},
	 getCurrentTime() {
	    const now = new Date();

	    const year = now.getFullYear();
	    const month = (now.getMonth() + 1).toString().padStart(2, '0'); // 月份补零
	    const day = now.getDate().toString().padStart(2, '0'); // 日期补零
	    const hours = now.getHours().toString().padStart(2, '0'); // 小时补零

	    // 返回格式化后的时间字符串，分钟和秒数固定为 00:00
	    return `${year}-${month}-${day} ${hours}:00:00`;
	 },
		// 定义一个方法，将本地时间转换为 UTC 格式
    convertToUTC(localTime) {
	  // 将本地时间字符串解析为 Date 对象
	  const localDate = new Date(localTime.replace(/-/g, '/')); // 兼容 iOS 的时间格式

	  // 获取 UTC 时间
	  const utcDate = new Date(localDate.getTime() - localDate.getTimezoneOffset() * 60000);

	  // 转换为 ISO 8601 格式
	  return utcDate.toISOString(); // 返回格式类似于 "2025-01-14T08:00:00.000Z"
	},
	//判断对象 数组 null 等数据是否为空 为空返回true
	/*
	 * param any数据
	 * returns 返回boolean
	 */
	isEmpty(value) {
		let a = false
		if (Object.prototype.toString.call(value) == '[object Array]') {
			a = value.length == 0 ? true : false
		} else if (Object.prototype.toString.call(value) == '[object Object]') {
			a = Object.keys(value).length == 0 ? true : false
		} else if (Object.prototype.toString.call(value) == '[object String]') {
			a = value.replace('/s', '').length == 0 ? true : false
		} else if (Object.prototype.toString.call(value) == '[object Number]') {
			a = isNaN(value) ? true : false
		} else if (Object.prototype.toString.call(value) == '[object Null]') {
			a = true
		} else if (Object.prototype.toString.call(value) == '[object Undefined]') {
			a = true
		} else if (Object.prototype.toString.call(value) == '[object Boolean]') {
			a = value ? false : true
		}
		return a
	},
  getLast30DaysRange() {
	  const endDate = new Date(); // 今天的日期
	  const startDate = new Date();
	  startDate.setDate(endDate.getDate() - 29); // 开始日期为 30 天前（包括今天）

	  // 格式化日期为 YYYY-MM-DD HH:mm:ss
	  const format = (date) => {
	    const year = date.getFullYear();
	    const month = String(date.getMonth() + 1).padStart(2, '0');
	    const day = String(date.getDate()).padStart(2, '0');
	    const hours = String(date.getHours()).padStart(2, '0');
	    const minutes = String(date.getMinutes()).padStart(2, '0');
	    const seconds = String(date.getSeconds()).padStart(2, '0');
	    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
	  };

	  return {
	    startDate: format(startDate),
	    endDate: format(endDate),
	  };
	},
	//防抖
	debounce(fn, delay) {
		let timer = null; //借助闭包
		return function() {
			if (timer) {
				clearTimeout(timer);
			}
			timer = setTimeout(fn, delay); // 简化写法
		};
	},
	//节流
	throttle(fn, delay) {
		let valid = true;
		return function() {
			if (!valid) {
				//休息时间 暂不接客
				return false;
			}
			// 工作时间，执行函数并且在间隔期内把状态位设为无效
			valid = false;
			setTimeout(() => {
				fn();
				valid = true;
			}, delay);
		};
	},
 	//上传文件
    uploadFile(file, callBack){
		// 检查文件权限
		// #ifdef APP-PLUS
		const platform = uni.getSystemInfoSync().platform.toLowerCase();
		if (platform === 'android') {
			// 安卓平台需要检查存储权限
			this.checkAndroidStoragePermission(() => {
				this.doUploadFile(file, callBack);
			}, () => {
				// 权限被拒绝
				uni.showToast({
					title: '无法访问存储，请授予权限',
					icon: 'none',
					duration: 2000
				});
				callBack && callBack({
					statusCode: 500,
					data: JSON.stringify({
						code: 500,
						msg: '无法访问存储，请授予权限'
					})
				});
			});
		} else {
			// 非安卓平台直接上传
			this.doUploadFile(file, callBack);
		}
		// #endif

		// #ifndef APP-PLUS
		// 非APP平台直接上传
		this.doUploadFile(file, callBack);
		// #endif
 	},

	// 实际执行上传的方法
	doUploadFile(file, callBack) {
		uni.uploadFile({
			url: config.http.baseURL + '/resource/app/oss/upload',
			filePath: file,
			name: 'file',
			header: {
				Authorization: 'Bearer ' + Cache.get('access_token')
			},
			success: (res) => {
				callBack && callBack(res)
			},
			fail: (err) => {
				callBack && callBack(err)
			}
		});
	},

	// 检查安卓存储权限
	checkAndroidStoragePermission(successCallback, failCallback) {
		// #ifdef APP-PLUS
		const permissions = [
			'android.permission.READ_EXTERNAL_STORAGE',
			'android.permission.WRITE_EXTERNAL_STORAGE'
		];

		plus.android.requestPermissions(
			permissions,
			function(resultObj) {
				let hasStoragePermission = false;
				for (let i = 0; i < resultObj.granted.length; i++) {
					const grantedPermission = resultObj.granted[i];
					if (permissions.includes(grantedPermission)) {
						hasStoragePermission = true;
						break;
					}
				}

				if (hasStoragePermission) {
					// 有存储权限，执行上传
					successCallback && successCallback();
				} else {
					// 没有存储权限，提示用户
					uni.showModal({
						title: '提示',
						content: '需要存储权限才能上传文件，请在设置中开启',
						confirmText: '去设置',
						success: function(res) {
							if (res.confirm) {
								// 打开应用设置页面
								const Intent = plus.android.importClass("android.content.Intent");
								const Settings = plus.android.importClass("android.provider.Settings");
								const Uri = plus.android.importClass("android.net.Uri");
								const mainActivity = plus.android.runtimeMainActivity();
								const intent = new Intent();
								intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
								const uri = Uri.fromParts("package", mainActivity.getPackageName(), null);
								intent.setData(uri);
								mainActivity.startActivity(intent);
							}
							failCallback && failCallback();
						}
					});
				}
			},
			function(error) {
				console.error('权限请求失败:', error);
				failCallback && failCallback();
			}
		);
		// #endif

		// #ifndef APP-PLUS
		successCallback && successCallback();
		// #endif
	},

	// 通用的选择媒体方法（适配安卓和微信小程序）
	chooseMedia(options, callback) {
		// 默认配置
		const defaultOptions = {
			count: 1,
			sizeType: ['original', 'compressed'],
			sourceType: ['album', 'camera'],
			mediaType: ['image'],
			maxDuration: 30
		};

		// 合并配置
		const mergedOptions = Object.assign({}, defaultOptions, options);

		// #ifdef APP-PLUS
		// 安卓平台先检查权限
		const platform = uni.getSystemInfoSync().platform.toLowerCase();
		if (platform === 'android') {
			// 检查相机权限和存储权限
			const permissions = [
				'android.permission.CAMERA',
				'android.permission.READ_EXTERNAL_STORAGE',
				'android.permission.WRITE_EXTERNAL_STORAGE'
			];

			plus.android.requestPermissions(
				permissions,
				(resultObj) => {
					let hasPermission = false;
					for (let i = 0; i < resultObj.granted.length; i++) {
						const grantedPermission = resultObj.granted[i];
						if (permissions.includes(grantedPermission)) {
							hasPermission = true;
							break;
						}
					}

					if (hasPermission) {
						// 有权限，执行选择媒体
						this.doChooseMedia(mergedOptions, callback);
					} else {
						// 没有权限，提示用户
						uni.showModal({
							title: '提示',
							content: '需要相机和存储权限才能选择媒体，请在设置中开启',
							confirmText: '去设置',
							success: function(res) {
								if (res.confirm) {
									// 打开应用设置页面
									const Intent = plus.android.importClass("android.content.Intent");
									const Settings = plus.android.importClass("android.provider.Settings");
									const Uri = plus.android.importClass("android.net.Uri");
									const mainActivity = plus.android.runtimeMainActivity();
									const intent = new Intent();
									intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
									const uri = Uri.fromParts("package", mainActivity.getPackageName(), null);
									intent.setData(uri);
									mainActivity.startActivity(intent);
								}
								// 回调失败
								callback && callback({
									errMsg: '没有相机或存储权限',
									tempFiles: []
								}, false);
							}
						});
					}
				},
				(error) => {
					console.error('权限请求失败:', error);
					// 回调失败
					callback && callback({
						errMsg: '权限请求失败',
						tempFiles: []
					}, false);
				}
			);
		} else {
			// 非安卓平台直接选择媒体
			this.doChooseMedia(mergedOptions, callback);
		}
		// #endif

		// #ifndef APP-PLUS
		// 非APP平台直接选择媒体
		this.doChooseMedia(mergedOptions, callback);
		// #endif
	},

	// 实际执行选择媒体的方法
	doChooseMedia(options, callback) {  
		uni.chooseImage({
			count: options.count,
			mediaType: options.mediaType,
			sourceType: options.sourceType,
			maxDuration: options.maxDuration,
			sizeType: options.sizeType,
			camera: options.camera,
			success: (res) => {
				// 直接调用options中的success回调
				if (options.success) {
					options.success(res);
				}
				// 如果有callback也调用
				callback && callback(res, true);
			},
			fail: (err) => {
				// 直接调用options中的fail回调
				if (options.fail) {
					options.fail(err);
				}
				// 如果有callback也调用
				callback && callback(err, false);
			},
			complete: options.complete
		});
	},

}
export default utils
